[Chapter7] - 연산자 오버로딩과 기타 관계

data class Point(val x: Int, val y: Int) {  
    operator fun plus(other: Point): Point {  
        return Point(x + other.x, y + other.y)  
    }  
}  
  
fun main() {  
    val p1 = Point(10, 20)  
    val p2 = Point(30, 40)  
    println(p1 + p2)  
}

// 'operator' modifier is required on 'plus' in 'part1.Point'
println(p1 + p2)

operator fun Point.times(scale: Double): Point {  
    return Point((x * scale).toInt(), (y * scale).toInt())  
}

p * 1.5 == 1.5 * p

operator fun <T> MutableCollection<T>.plusAssign(element: T) {
	this.add(element)
}

fun main() {  
    val list = arrayListOf(1, 2)  
    list += 3  
    val newList = list + listOf(4, 5)  
    // [1, 2, 3]
    println(list)
	// [1, 2, 3, 4, 5]  
    println(newList)  
}

operator fun Point.unaryMinus(): Point {  
    return Point(-x, -y)  
}

fun main() {
	val p = Point(10, 20)
	// Point(x=-10, y=-20)
	println(-p)
}

operator fun BigDecimal.inc() = this + BigDecimal.ONE

public open operator fun equals(other: Any?): Boolean

override fun equals(other: Any?): Boolean {  
	if (other === this) return true  
	if (other !is Point) return false  
	return other.x == x && other.y == y  
}

private class Person(  
	val firstName: String,  
	val lastName: String  
) : Comparable<Person> {  
	override fun compareTo(other: Person): Int {  
		return compareValuesBy(this, other, Person::lastName, Person::firstName)  
	}  
}  
  
fun main() {  
	val p1 = Person("Alice", "Smith")  
	val p2 = Person("Bob", "Johnson")
	// 출력 : false  
	println(p1 < p2)  
}

operator fun Point.get(index: Int): Int {  
	return when(index) {  
		0 -> x  
		1 -> y  
		else -> throw IndexOutOfBoundsException("Invalid coordinate $index")  
	}  
}

operator fun Point.set(index: Int, value: Int) {  
	when(index) {  
		0 -> x = value  
		1 -> y = value  
		else -> throw IndexOutOfBoundsException("Invalid coordinate $index")  
	}  
}

fun main() {
	val p = Point(10, 20)
	// 출력 : get = 20
	println("get = ${p[1]}")
	
	p1[0] = 20
	// 출력 : set = 20
	println("set = ${p[1]}")
}

data class Rectangle(val upperLeft: Point, val lowerRight: Point)

operator fun Rectangle.contains(p: Point): Boolean {  
	return p.x in upperLeft.x until lowerRight.x && 
		   p.y in upperLeft.y until lowerRight.y  
}

fun main() {  
	val rect = Rectangle(Point(10, 20), Point(50, 50))  
	// 출력 : true
	println(Point(20, 30) in rect)
	// 출력 : false
	println(Point(5, 5) in rect)
}

fun main() {  
	val now = LocalDate.now()  
	val vacation = now..now.plusDays(10)
	// 출력 : true
	println(now.plusWeeks(1) in vacation)  
}

val n = 9
// 출력 : 0..10
println(0..(n + 1))

operator fun ClosedRange<LocalDate>.iterator(): Iterator<LocalDate> =  
	object : Iterator<LocalDate> {  
		var current = start  
		override fun hasNext(): Boolean = current <= endInclusive  
		override fun next(): LocalDate = current.apply {  
			current = plusDays(1)  
		}  
	}

fun main() {  
	val newYear = LocalDate.ofYearDay(2023, 1)  
	val daysOff = newYear.minusDays(1)..newYear  
	// 출력 : 2022-12-31
	// 출력 : 2023-01-01
	for (dayOff in daysOff) println(dayOff)  
}

fun main() {  
	val p = Point(10, 20)  
	val (x, y) = p  
	println("x = $x, y = $y")  
}

private class Point(val x: Int, val y: Int) {  
	operator fun component1() = x  
	operator fun component2() = y  
}

data class NameComponents(val name: String, val extension: String)

fun splitFilename(fullName: String): NameComponents { 
	val result = fullName.split(".", limit = 2)  
	return NameComponents(result[0], result[1])  
}  

fun main() {
	val (name, ext) = splitFilename("example.kt)
	// 출력 : example
	println(name)
	// 출력 : kt
	println(ext)
}

fun printEntries(map: Map<String, String>) {  
	for ((key, value) in map) {  
		println("$key -> $value")  
	}  
}

private class Foo {  
	var p: Type by Delegate()  
}

class Foo {
	// 컴파일러가 생성한 도우미 프로퍼티
	private val delegate = Delegate()

	// 해당 프로퍼티를 위해 컴파일러가 생성한 접근자는 delegate의 getValue와 setValue 메소드를 호출한다.
	var p: Type
		set(value: Type) = delegate.setValue(..., value)
		get() = delegate.getValue(...)
}

class Delegate {  
	operator fun getValue() {...}  
	operator fun setValue(..., value: Type) {...}  
}
class Foo {
	var p: Type by Delegate()
}

fun main() {
	val foo = Foo()
	val oldValue = foo.p
	foo.p = newValue
}

fun loadEmails(person: Person): List<Email> {  
	println("${person.name}의 이메일을 가져옴")  
	return findAllEmailByPerson(person)  
}

class Person(val name: String, var age: Int) {  
	private var _emails: List<Email>? = null  
	val emails: List<Email>  
		get() {  
			if(_emails == null) {  
				_emails = loadEmails(this)  
			}  
			return _emails!!  
		}  
}

class Person(val name: String, var age: Int) {  
	val emails by lazy { loadEmails(this) }  
}

class PropertyChangeAware {  
	protected val changeSupport = PropertyChangeSupport(this)  
	  
	fun addPropertyChangeListener(listener: PropertyChangeListener) {  
		changeSupport.addPropertyChangeListener(listener)  
	}  
	  
	fun removePropertyChangeListener(listener: PropertyChangeListener) {
		changeSupport.removePropertyChangeListener(listener)  
	}  
}

class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {  
	var age: Int = age  
		set(newValue) {  
			val oldValue = field  
			field = newValue  
			changeSupport.firePropertyChange("age", oldValue, newValue)  
		}  
	var salary: Int = salary  
		set(newValue) {  
			val oldValue = field  
			field = newValue  
			changeSupport.firePropertyChange("salary", oldValue, newValue)  
		}  
}

fun main() {  
	val p = Person("Dmitry", 34, 2000)  
	p.addPropertyChangeListener(  
		PropertyChangeListener { event ->  
			println("""  
			Property ${event.propertyName} changedfrom ${event.oldValue} to ${event.newValue}  
			""".trimIndent())  
		}  
	)  
	// 출력 : Property age changed from 34 to 35
	p.age = 35  
	// 출력 : Property age changed from 2000 to 2100
	p.salary = 2100  
}

class ObservableProperty(  
	val propName: String, var propValue: Int,  
	val changeSupport: PropertyChangeSupport  
) {  
	fun getValue(): Int = propValue  
	fun setValue(newValue: Int) {  
		val oldValue = propValue  
		propValue = newValue  
		changeSupport.firePropertyChange(propName, oldValue, newValue)  
	}  
}

private class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {  
	val _age = ObservableProperty("age", age, changeSupport)  
	var age: Int  
		get() = _age.getValue()  
		set(value) { _age.setValue(value) }  
	val _salary = ObservableProperty("salary", salary, changeSupport)  
	var salary: Int  
		get() = _salary.getValue()  
		set(value) { _salary.setValue(value) }  
}

class ObservableProperty(  
	var propValue: Int, val changeSupport: PropertyChangeSupport  
) {  
	operator fun getValue(p: Person, prop: KProperty<*>): Int = propValue  
	operator fun setValue(p: Person, prop: KProperty<*>, newValue: Int) {  
		val oldValue = propValue  
		propValue = newValue  
		changeSupport.firePropertyChange(prop.name, oldValue, newValue)  
	}  
}

class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {  
	val age: Int by ObservableProperty(age, changeSupport)  
	var salary: Int by ObservableProperty(salary, changeSupport)  
}

class C {
	var prop: Type by MyDelegate()
}

val c = C()

class C {
	private val <delegate> = MyDelegate()
	var prop: Type
		get() = <delegate>.getValue(this, <property>)
		set(value: Type) = <delegate>.setValue(this, <property>, value)
}

private class Person {  
	private val _attributes = hashMapOf<String, String>()  
	fun setAttribute(attrName: String, value: String) {  
		_attributes[attrName] = value  
	}  
	val name: String  
		get() = _attributes["name"]!!  
}  
  
fun main() {  
	val p = Person()  
	val data = mapOf("name" to "Dmitry", "company" to "JetBrains")  
	for ((attrName, value) in data) {  
		p.setAttribute(attrName, value)  
	}  
	println(p.name)  
}

private class Person2 {  
	private val _attributes = hashMapOf<String, String>()  
	fun setAttribute(attrName: String, value: String) {  
		_attributes[attrName] = value  
	}  
	val name: String by _attributes  
}

object Users : IdTable() {  
	val name = varchar("name", length = 50).index()  
	val age = integer("age")  
}  
  
class User(id: EntityId) : Entity(id) {  
	var name: String by Users.name
	var age: Int by Users.age
}